home *** CD-ROM | disk | FTP | other *** search
/ Shareware Grab Bag / Shareware Grab Bag.iso / 007 / 8087.arc / 87STACK.BAS (.txt) < prev    next >
Encoding:
GW-BASIC  |  1985-02-13  |  17.5 KB  |  304 lines

  1. 1000   ' |---------------------------------------------|
  2. 1010   ' |    Example for 8087 Programming, Part 3     |
  3. 1020   ' |    Personal Computer Age 3.1 Solveware      |
  4. 1030   ' | Demonstrate 8087 Register Stack Operations  |
  5. 1040   ' |---------------------------------------------|
  6. 1050   '
  7. 1060                          '*Reserve space for machine
  8. 1070                          '*language subroutines
  9. 1080          CLEAR ,29999
  10. 1090                          '*Initialize screen, variable
  11. 1100                          '*types, 8087 tag word masks,
  12. 1110                          '*and subroutine starting
  13. 1120                          '*addresses
  14. 1130          CLS                                                                    :KEY OFF                                                                        :PRINT "Storing machine code. . ."
  15. 1140          DEFINT A-Z                                                             :DIM MASK(3), MTAG(7)
  16. 1150        MASK(0)=3                                                              :MASK(1)=12                                                                     :MASK(2)=48                                                                     :MASK(3)=192
  17. 1160          INIT87=30000
  18. 1170          LD87=30020
  19. 1180          ADD87=30070
  20. 1190          MUL87=30100
  21. 1200          ST87=30130
  22. 1210          TRANS=30180
  23. 1220                         '
  24. 1230                         '*Load machine language
  25. 1240                         '*subroutines
  26. 1250        ADDR=INIT87                                                            :CHKSUM=2383                                                                    :ROUTINE$="INIT87"                                                              :GOSUB 1670
  27. 1260        ADDR=LD87                                                              :CHKSUM=4935                                                                    :ROUTINE$="LD87"                                                                :GOSUB 1670
  28. 1270        ADDR=ADD87                                                             :CHKSUM=2765                                                                    :ROUTINE$="ADD87"                                                               :GOSUB 1670
  29. 1280        ADDR=MUL87                                                             :CHKSUM=2773                                                                    :ROUTINE$="MUL87"                                                               :GOSUB 1670
  30. 1290        ADDR=ST87                                                              :CHKSUM=4912                                                                    :ROUTINE$="ST87"                                                                :GOSUB 1670
  31. 1300        ADDR=TRANS                                                             :CHKSUM=5092                                                                    :ROUTINE$="TRANS"                                                               :GOSUB 1670
  32. 1310                             '*Describe calculation to
  33. 1320                             '*be demonstrated and
  34. 1330                             '*get parameter values
  35. 1340        CLS
  36. 1350        LOCATE 3,10                                                            :PRINT "The equation to be solved is:"
  37. 1360        LOCATE 5,30                                                            :PRINT "X=(A+B)*(C+D)"
  38. 1370        LOCATE 8,10                                                            :INPUT "Enter the value of A:   ",A!
  39. 1380        LOCATE 8,29:PRINT SPC(15):LOCATE 8,29:INPUT "B: ",B!
  40. 1390        LOCATE 8,29:PRINT SPC(15):LOCATE 8,29:INPUT "C: ",C!
  41. 1400        LOCATE 8,29:PRINT SPC(15):LOCATE 8,29:INPUT "D: ",D!
  42. 1410                             '
  43. 1420                             '*Perform demonstration
  44. 1430                             '
  45. 1440        GOSUB 1770
  46. 1450        ADDR=32000
  47. 1460        CALL INIT87(ADDR)                                                      :IN$="FINIT"                                                                    :GOSUB 1910                                                                     :GOSUB 2160
  48. 1470        CALL LD87(A!,ADDR)                                                     :IN$="FLD  "                                                                    :GOSUB 1910                                                                     :GOSUB 2160
  49. 1480        CALL LD87(B!,ADDR)                                                     :IN$="FLD  "                                                                    :GOSUB 1910                                                                     :GOSUB 2160
  50. 1490        CALL ADD87(ADDR)                                                       :IN$="FADD "                                                                    :GOSUB 1910                                                                     :GOSUB 2160
  51. 1500        CALL LD87(C!,ADDR)                                                     :IN$="FLD  "                                                                    :GOSUB 1910                                                                     :GOSUB 2160
  52. 1510        CALL LD87(D!,ADDR)                                                    :IN$="FLD  "                                                                    :GOSUB 1910                                                                     :GOSUB 2160
  53. 1520        CALL ADD87(ADDR)                                                       :IN$="FADD "                                                                    :GOSUB 1910                                                                     :GOSUB 2160
  54. 1530        CALL MUL87(ADDR)                                                       :IN$="FMUL "                                                                    :GOSUB 1910                                                                     :GOSUB 2160
  55. 1540        CALL ST87(X!,ADDR)                                                     :IN$="FSTP "                                                                    :GOSUB 1910
  56. 1550                             '
  57. 1560        LOCATE 16,60                                                           :PRINT "Result is:"                                                             :LOCATE 18,59                                                                   :PRINT X!
  58. 1570                             '
  59. 1580                             '*Calculate another or exit
  60. 1590                             '
  61. 1600        LOCATE 22,1                                                            :PRINT "Do you wish to calculate again (y/n)?"
  62. 1610        Q$=INKEY$                                                              :IF Q$="" THEN 1610 ELSE IF Q$="y" OR Q$="Y" THEN 1340 ELSE IF Q$="n" OR Q$="N"THEN 1620 ELSE BEEP: GOTO 1610
  63. 1620        CLS
  64. 1630        END
  65. 1640                             '*Subroutine to load machine
  66. 1650                             '*language instructions
  67. 1660                             '*(hex values)
  68. 1670        READ M: IF M<>1000 THEN POKE ADDR,M:CHKSUM=CHKSUM-M:ADDR=ADDR+1:GOTO 1670 ELSE IF CHKSUM=0 THEN RETURN
  69. 1680                             '
  70. 1690                             '*Checksum error
  71. 1700                             '
  72. 1710        PRINT                                                                  :PRINT "Coding errors in ";ROUTINE$;"--please check DATA statements"
  73. 1720                             '
  74. 1730        END
  75. 1740                             '
  76. 1750                             '*Subroutine to draw
  77. 1760                             '*stack diagram
  78. 1770        CLS
  79. 1780        L1$=STRING$(18,205)                                                    :L2$=STRING$(18,32)
  80. 1790        LOCATE 3,30                                                            :PRINT CHR$(201)+L1$+CHR$(187)
  81. 1800        FOR REGNUM=0 TO 6
  82. 1810        LOCATE 2*REGNUM+4,23                                                   :PRINT "ST(";CHR$(REGNUM+48);")  "+CHR$(186)+L2$+CHR$(186)
  83. 1820        LOCATE 2*REGNUM+5,30                                                   :PRINT CHR$(204)+L1$+CHR$(185)
  84. 1830        NEXT
  85. 1840        LOCATE 18,23                                                           :PRINT "ST(7)  "+CHR$(186)+L2$+CHR$(186)
  86. 1850        LOCATE 19,30                                                           :PRINT CHR$(200)+L1$+CHR$(188)
  87. 1860        LOCATE 4,60                                                            :PRINT "Last instruction:"
  88. 1870        RETURN
  89. 1880                             '
  90. 1890                             '*Subroutine to update
  91. 1900                             '*stack values
  92. 1910        LOCATE 6,60                                                            :PRINT IN$
  93. 1920        TAG=PEEK(ADDR+4)
  94. 1930        FOR I=0 TO 3                                                           :MTAG(I)=(TAG AND MASK(I)  )/4^I                                                :NEXT
  95. 1940        TAG=PEEK(ADDR+5)
  96. 1950        FOR I=4 TO 7                                                           :MTAG(I)=(TAG AND MASK(I-4))/4^(I-4)                                            :NEXT
  97. 1960        TOP=(PEEK (ADDR+3) AND 56)/8
  98. 1970        FOR I=0 TO 7
  99. 1980        J=(TOP+I) MOD 8
  100. 1990        IF MTAG(J)<>0 THEN 2060
  101. 2000        INPAD=ADDR+14+10*I
  102. 2010        CALL TRANS(INPAD,OUTPT!)
  103. 2020        ST$=STR$(OUTPT!)
  104. 2030        FOR K=1 TO 16 -LEN(ST$)
  105. 2040          IF (K MOD 2)<>0 THEN ST$=ST$ + " " ELSE ST$=" "+ST$
  106. 2050        NEXT K
  107. 2060        IF MTAG(J)=1 THEN ST$="     zero      ":GOTO 2100
  108. 2070        IF MTAG(J)=2 THEN ST$="    special    ":GOTO 2100
  109. 2080        IF MTAG(J)=3 THEN ST$="     empty     ":GOTO 2100
  110. 2090                                 '
  111. 2100        LOCATE 4+2*I,32                                                        :PRINT ST$
  112. 2110        NEXT I
  113. 2120        RETURN
  114. 2130                                 '
  115. 2140                                 '*Subroutine to
  116. 2150                                 '*continue on request
  117. 2160        LOCATE 22,1                                                            :PRINT "Press any key to continue. . ."
  118. 2170        A$=INKEY$:IF A$="" THEN 2170
  119. 2180        RETURN
  120. 2190        '
  121. 2200        ' |-----------------------------------------|
  122. 2210        ' |   INIT87: 8087 Intialization Routine    |
  123. 2220        ' |-----------------------------------------|
  124. 2230                       '
  125. 2240                       '*Get argument addresses
  126. 2250                       '
  127. 2260        DATA &h55:              'push    bp
  128. 2270        DATA &h8B, &hEC:        'mov     bp,sp
  129. 2280        DATA &h8B, &h5E, &h06:  'mov     bx,[bp]+6
  130. 2290        DATA &h8B, &h3F:        'mov     di,[bx]
  131. 2300                       '
  132. 2310                       '*Initialize the 8087
  133. 2320                       '*and save its state
  134. 2330        DATA &h9B, &hDB, &hE3:  'finit
  135. 2340        DATA &h9B, &hDD, &h35:  'fsave   [di]
  136. 2350        DATA &h9B:              'fwait
  137. 2360                       '
  138. 2370                       '*Restore the BP register
  139. 2380                       '*and return to BASIC
  140. 2390        DATA &h5D:              'pop     bp
  141. 2400        DATA &hCA, &h02, &h00:  'ret     2
  142. 2410        DATA 1000
  143. 2420        '
  144. 2430        ' |-----------------------------------------|
  145. 2440        ' |  LD87:  8087 Parameter Loading Routine  |
  146. 2450        ' |-----------------------------------------|
  147. 2460                       '
  148. 2470                       '*Get argument addresses
  149. 2480                       '
  150. 2490        DATA &h55:              'push    bp
  151. 2500        DATA &h8B, &hEC:        'mov     bp,sp
  152. 2510        DATA &h8B, &h76, &h08:  'mov     si,[bp]+8
  153. 2520        DATA &h8B, &h5E, &h06:  'mov     bx,[bp]+6
  154. 2530        DATA &h8B, &h3F:        'mov     di,[bx]
  155. 2540                       '*Convert input from
  156. 2550                       '*single-precision BASIC
  157. 2560                       '*to 8087 short real format
  158. 2570        DATA &h8B, &h44, &h02:  'mov     ax,[si]+2
  159. 2580        DATA &h80, &hFC, &h02:  'cmp     ah,2
  160. 2590        DATA &h72, &h0A:        'jb      (+10)
  161. 2600        DATA &h80, &hEC, &h02:  'sub     ah,2
  162. 2610        DATA &hD0, &hC0:        'rol     al,1
  163. 2620        DATA &hD1, &hC8:        'ror     ax,1
  164. 2630        DATA &h89, &h44, &h02:  'mov     [si]+2.ax
  165. 2640                       '*Restore state, load
  166. 2650                       '*parameter into 8087 stack,
  167. 2660                       '*and save the state
  168. 2670        DATA &h9B, &hDD, &h25:  'frstor  [di]                                2680       DATA &h9B, &hD9, &h04:  'fld     dword ptr [si]
  169. 2680        DATA &h9B, &hD9, &h04:  'fld     dword ptr [si]
  170. 2690        DATA &h9B, &hDD, &h35:  'fsave   [di]
  171. 2700        DATA &h9B:              'fwait
  172. 2710                       '
  173. 2720                       '*Restore the BP register
  174. 2730                       '*and return to BASIC
  175. 2740        DATA &h5D:              'pop     bp
  176. 2750        DATA &hCA, &h04, &h00:  'ret     4
  177. 2760        DATA 1000
  178. 2770        '
  179. 2780        ' |------------------------------------|
  180. 2790        ' |    ADD87: 8087 Addition Routine    |
  181. 2800        ' |------------------------------------|
  182. 2810                       '
  183. 2820                       '*Get argument addresse
  184. 2830                       '
  185. 2840        DATA &h55:              'push    bp
  186. 2850        DATA &h8B, &hEC:        'mov     bp,sp
  187. 2860        DATA &h8B, &h5E, &h06:  'mov     bx,[bp]+6
  188. 2870        DATA &h8B, &h3F:        'mov     di,[bx]
  189. 2880                       '*Restore state,
  190. 2890                       '*add ST to ST(1) and pop,
  191. 2900                       '*save 8087 state
  192. 2910        DATA &h9B, &hDD, &h25:  'frstor  [di]
  193. 2920        DATA &h9B, &hDE, &hC1:  'faddp   st(1),st
  194. 2930        DATA &h9B, &hDD, &h35:  'fsave   [di]
  195. 2940        DATA &h9B:              'fwait
  196. 2950                       '
  197. 2960                       '*Restore the BP register
  198. 2970                       '*and return to BASIC
  199. 2980        DATA &h5D:              'pop     bp
  200. 2990        DATA &hCA, &h02, &h00:  'ret     2
  201. 3000        DATA 1000
  202. 3010        '
  203. 3020        ' |---------------------------------------|
  204. 3030        ' |  MUL87: 8087 Mulitiplication Routine  |
  205. 3040        ' |---------------------------------------|
  206. 3050                       '
  207. 3060                       '*Get argument addresses
  208. 3070                       '
  209. 3080        DATA &h55:              'push    bp
  210. 3090        DATA &h8B, &hEC:        'mov     bp,sp
  211. 3100        DATA &h8B, &h5E, &h06:  'mov     bx,[bp]+6
  212. 3110        DATA &h8B, &h3F:        'mov     di,[bx]
  213. 3120                       '*Restore state,
  214. 3130                       '*multiply ST(1) by ST
  215. 3140                       '*and pop, save 8087 state
  216. 3150        DATA &h9B, &hDD, &h25:  'frstor  [di]
  217. 3160        DATA &h9B, &hDE, &hC9:  'fmulp   st(1),st
  218. 3170        DATA &h9B, &hDD, &h35:  'fsave   [di]
  219. 3180        DATA &h9B:              'fwait
  220. 3190                       '
  221. 3200                       '*Restore the BP register
  222. 3210                       '*and return to BASIC
  223. 3220        DATA &h5D:              'pop     bp
  224. 3230        DATA &hCA, &h02, &h00:  'ret     2
  225. 3240        DATA 1000
  226. 3250        '
  227. 3260        ' |----------------------------------------|
  228. 3270        ' |  ST87: 8087 Parameter Storing Routine  |
  229. 3280        ' |----------------------------------------|
  230. 3290                       '
  231. 3300                       '*Get argument addresses
  232. 3310                       '
  233. 3320        DATA &h55:              'push    bp
  234. 3330        DATA &h8B, &hEC:        'mov     bp,sp
  235. 3340        DATA &h8B, &h76, &h08:  'mov     si.[bp]+8
  236. 3350        DATA &h8B, &h5E, &h06:  'mov     bx,[bp]+6
  237. 3360        DATA &h8B, &h3F:        'mov     di,[bx]
  238. 3370                       '*Restore state,
  239. 3380                       '*save parameter from 8087
  240. 3390                       '*stack, and save the state
  241. 3400        DATA &h9B, &hDD, &h25:  'frstor  [di]
  242. 3410        DATA &h9B, &hD9, &h1C:  'fstp    dword ptr [si]
  243. 3420        DATA &h9B, &hDD, &h35:  'fsave   [di]
  244. 3430        DATA &h9B:              'fwait
  245. 3440                       '*Convert input from 8087
  246. 3450                       '*short real format to
  247. 3460                       '*single-precision BASIC
  248. 3470        DATA &h8B, &h44, &h02:  'mov     ax,[si]+2
  249. 3480        DATA &hD1, &hC0:        'rol     ax,1
  250. 3490        DATA &hD0, &hC8:        'ror     al,1
  251. 3500        DATA &h80, &hFC, &h00:  'cmp     ah,0
  252. 3510        DATA &h74, &h03:        'je      (+3)
  253. 3520        DATA &h80, &hC4, &h02:  'add     ah,2
  254. 3530        DATA &h89, &h44, &h02:  'mov     [si]+2,ax
  255. 3540                       '
  256. 3550                       '*Restore the BP register
  257. 3560                       '*and return to BASIC
  258. 3570        DATA &h5D:              'pop     bp
  259. 3580        DATA &hCA, &h04, &h00:  'ret     2
  260. 3590        DATA 1000
  261. 3600        '
  262. 3610        ' |-----------------------------------------|
  263. 3620        ' | TRANS: Variable Type Conversion Routine |
  264. 3630        ' |-----------------------------------------|
  265. 3640                       '
  266. 3650                       '*Get argument addresses
  267. 3660                       '
  268. 3670        DATA &h55:              'push    bp
  269. 3680        DATA &h8B, &hEC:        'mov     bp,sp
  270. 3690        DATA &h8B, &h5E, &h08:  'mov     bx,[bp]+8
  271. 3700        DATA &h8B, &h37:        'mov     si,word ptr [bx]
  272. 3710        DATA &h8B, &h7E, &h06:  'mov     di,[bp]+6
  273. 3720        DATA &h9B, &hDB, &hE3:  'finit
  274. 3730                       '*Initialize 8087, load
  275. 3740                       '*register contents (in
  276. 3750                       '*temporary real format),
  277. 3760                       '*store register contents
  278. 3770                       '*saved by previous FSAVE
  279. 3780                       '*in short real format.
  280. 3790        DATA &h9B, &hDB, &h2C:  'fld     tbyte ptr [si]
  281. 3800        DATA &h9B, &hD9, &h1D:  'fstp    dword ptr [di]
  282. 3810        DATA &h9B:              'fwait
  283. 3820                       '*Convert input from 8087
  284. 3830                       '*short real format to
  285. 3840                       '*single-precision BASIC
  286. 3850        DATA &h8B, &h45, &h02:  'mov     ax,word ptr [di]+2
  287. 3860        DATA &hD1, &hC0:        'rol     ax,1
  288. 3870        DATA &hD0, &hC8:        'ror     al,1
  289. 3880        DATA &h80, &hFC, &h00:  'cmp     ah,0
  290. 3890        DATA &h74, &h03:        'je      (+3)
  291. 3900        DATA &h80, &hC4, &h02:  'add     ah,2
  292. 3910        DATA &h89, &h45, &h02:  'mov     word ptr [di]+2,ax
  293. 3920                       '
  294. 3930                       '*Restore the BP register
  295. 3940                       '*and return to BASIC
  296. 3950        DATA &h5D:              'pop     bp
  297. 3960        DATA &hCA, &h04, &h00:  'ret     4
  298. 3970                       '*"Flag" value signals end
  299. 3980                       '*of data to terminate
  300. 3990                       '*loops (typical for all
  301. 4000                       '*named subroutines)
  302. 4010        DATA 1000
  303. 4020        END
  304.